package com.cougil.uoc.seghismed.business;

import iaik.x509.X509Certificate;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.cougil.uoc.seghismed.cipher.P12;
import com.cougil.uoc.seghismed.model.Historial;
import com.cougil.uoc.seghismed.model.Metge;
import com.cougil.uoc.seghismed.model.Pacient;
import com.cougil.uoc.seghismed.model.Usuari;
import com.cougil.uoc.seghismed.model.Visita;
import com.cougil.uoc.seghismed.model.ciphed.HistorialCiphed;
import com.cougil.uoc.seghismed.model.ciphed.MetgeCiphed;
import com.cougil.uoc.seghismed.model.ciphed.PacientCiphed;
import com.cougil.uoc.seghismed.model.ciphed.UsuariCiphed;
import com.cougil.uoc.seghismed.model.ciphed.VisitaCiphed;
import com.cougil.uoc.seghismed.model.comunicacions.Peticio;
import com.cougil.uoc.seghismed.model.comunicacions.Resposta;
import com.cougil.uoc.seghismed.model.comunicacions.ciphed.PeticioCiphed;
import com.cougil.uoc.seghismed.model.comunicacions.ciphed.RespostaCiphed;

/**
 * Interfície que ofereix els principals métodes de xifratge i signatura de dades entre els diversos
 * objectes de negoci a Seghismed
 *
 * @author Ignacio Cougil Jares
 *
 */
public interface CipherService {

	/**
	 * Retorna el metge desxifrat pel destinatari informat emprant la seva clau privada
	 * @param mCiphed {@link MetgeCiphed} metge xifrat que es preten desxifrar
	 * @param destinatari {@link Usuari} destinatari amb quina clau privada s'intentarà desxifrar la informació
	 * @return Metge metge desxifrat
	 */
	public Metge desxifrarMetge(MetgeCiphed mCiphed, Usuari destinatari);

	/**
	 * Retorna el mapa {@link Map} desxifrat que conté el conjunt de metges amb accés protegit
	 * @param metgesAmbAccesProtegit {@link Map} mapa amb el conjunt de metges amb l'accés protegit
	 * @param destinatari {@link Usuari} pel qual es preten desxifrar el mapa
	 * @return mapa {@link Map} amb el conjunt de metges desxifrats
	 */
	public Map<Metge, Date> desxifrarMetgesAmbAccesProtegit(Map<MetgeCiphed, Date> metgesAmbAccesProtegit,
			Usuari destinatari);

	/**
	 * Retorna el pacient desxifrat pel destinatari informat emprant la seva clau privada
	 * @param pCiphed {@link PacientCiphed} pacient xifrat que es preten desxifrar
	 * @param destinatari {@link Usuari} destinatari amb quina clau privada s'intentarà desxifrar la informació
	 * @return Pacient pacient desxifrat
	 */
	public Pacient desxifrarPacient(PacientCiphed pCiphed, Usuari destinatari);

	/**
	 * Retorna la llista {@link List} desxifrada que conté el conjunt de pacients protegits emprant
	 * la clau privada del destinatari per intentar-ho
	 *
	 * @param pacientsCiphed
	 *            {@link List} conjunt de pacients protegits xifrats pel Gestor
	 * @param destinatari
	 *            {@link Usuari} pel qual es preten desxifrar la llista
	 * @return llista {@link List} amb el conjunt de pacients desxifrats
	 */
	public List<Pacient> desxifrarPacientsProtegits(List<PacientCiphed> pacientsCiphed, Usuari destinatari);

	/**
	 * Retorna una petició desxifrada pel destinatari informat emprant la seva clau privada
	 *
	 * @param pCiphed
	 *            Petició xifrada
	 * @param destinatari
	 *            {@link Usuari} destinatari de la petició amb quina clau privada s'intentarà
	 *            desxifrar la informació
	 * @return Petició desxifrada
	 */
	public Peticio desxifrarPeticio(PeticioCiphed pCiphed, Usuari destinatari);

	/**
	 * Retorna una resposta desxifrada pel destinatari informat emprant la seva clau privada
	 * @param rCiphed Resposta xifrada
	 * @param destinatari {@link Usuari} destinatari de la resposta amb quina clau privada s'intentarà desxifrar
	 * la informació
	 * @return Resposta desxifrada
	 */
	public Resposta desxifrarResposta(RespostaCiphed rCiphed, Usuari destinatari);

	/**
	 * Retorna l'usuari desxifrat pel destinatari informat, emprant la seva clau privada
	 *
	 * @param uCiphed
	 *            {@link UsuariCiphed} usuari que es preten desxifrar
	 * @param destinatari
	 *            {@link Usuari} destinatari amb quina clau privada s'intentarà desxifrar la
	 *            informació
	 * @return Usuari usuari desxifrat
	 */
	public Usuari desxifrarUsuari(UsuariCiphed uCiphed, Usuari destinatari);

	/**
	 * Retorna l'objecte encarregat de gestionar les dades del contenidor PKCS#12 de l'usuari
	 * informat
	 * 
	 * @param usuari
	 *            {@link Usuari} pel qual es vol obtenir el seu objecte P12 {@link P12}
	 * @return objecte trobat dintre del conjunt ja existent o la seva nova instància associada
	 */
	public P12 getP12(Usuari usuari);

	/**
	 * Retorna l'objecte certificat X509 de l'usuari informat
	 * 
	 * @param usuari
	 *            {@link Usuari} pel qual es vol obtenir el seu objecte X509 {@link X509Certificate}
	 * @return objecte trobat dintre del conjunt ja existent o la seva nova instància associada
	 */
	public X509Certificate getX509(Usuari usuari);

	/**
	 * Retorna l'historial xifrat i signat pel destinatari informat en base a l'historial facilitat,
	 * emprant la seva clau pública i la clau privada de l'emisor
	 *
	 * @param historial
	 *            {@link Historial} que es preten xifrar i signar
	 * @param emisor
	 *            {@link Usuari} amb quina clau privada s'intentarà xifrar la informació
	 * @param destinatari
	 *            {@link Usuari} destinatari de la petició amb quina clau pública s'intentarà xifrar
	 *            i signar la informació
	 * @return Historial xifrat i signat
	 */
	public HistorialCiphed signarXifrarHistorial(Historial historial, Usuari emisor, Usuari destinatari);

	/**
	 * Retorna el pacient xifrat i signat pel destinatari informat en base al pacient facilitat,
	 * emprant la seva clau pública i la clau privada de l'emisor
	 *
	 * @param pacient
	 *            {@link Pacient} que es preten xifrar i signar
	 * @param emisor
	 *            {@link Usuari} amb quina clau privada s'intentarà xifrar la informació
	 * @param destinatari
	 *            {@link Usuari} destinatari de la petició amb quina clau pública s'intentarà xifrar
	 *            i signar la informació
	 * @return Pacient xifrat i signat
	 */
	public PacientCiphed signarXifrarPacient(Pacient pacient, Usuari emisor, Usuari destinatari);

	/**
	 * Retorna el visita xifrat i signat pel destinatari informat en base al visita facilitat,
	 * emprant la seva clau pública i la clau privada de l'emisor
	 *
	 * @param visita
	 *            {@link Visita} que es preten xifrar i signar
	 * @param emisor
	 *            {@link Usuari} amb quina clau privada s'intentarà xifrar la informació
	 * @param destinatari
	 *            {@link Usuari} destinatari de la petició amb quina clau pública s'intentarà xifrar
	 *            i signar la informació
	 * @return Visita xifrada i signada
	 */
	public VisitaCiphed signarXifrarVisita(Visita visita, Usuari emisor, Usuari destinatari);

	/**
	 * Retorna l'historial desxifrat i verificat pel destinatari informat en base a l'historial
	 * xifrat facilitat, emprant la clau privada del destinatari
	 *
	 * @param hCiphed
	 *            historial xifrat {@link HistorialCiphed} que es preten desxifrar i verificar
	 * @param destinatari
	 *            {@link Usuari} amb quina clau privada s'intentarà desxifrar la informació
	 * @return Historial desxifrat i verificat
	 */
	public Historial verificarDesxifrarHistorial(HistorialCiphed hCiphed, Usuari destinatari);

	/**
	 * Retorna el metge desxifrat i verificat pel destinatari informat en base al metge xifrat
	 * facilitat, emprant la clau privada del destinatari
	 *
	 * @param mCiphed
	 *            metge xifrat {@link MetgeCiphed} que es preten desxifrar i verificar
	 * @param destinatari
	 *            {@link Usuari} amb quina clau privada s'intentarà desxifrar la informació
	 * @return Metge desxifrat i verificat
	 */
	public Metge verificarDesxifrarMetge(MetgeCiphed mCiphed, Usuari destinatari);

	/**
	 * Retorna el mapa {@link Map} desxifrat que conté el conjunt de metges amb accés protegit
	 *
	 * @param metgesCiphed
	 *            {@link Map} conjunt de metges amb accés protegit signats i verificats pel Gestor
	 * @param destinatari
	 *            {@link Usuari} pel qual es preten desxifrar i verificar el mapa
	 * @return mapa {@link Map} amb el conjunt de metges amb dates d'accés desxifrats
	 */
	public Map<Metge, Date> verificarDesxifrarMetgesAmbAccesProtegit(
			Map<MetgeCiphed, Date> metgesCiphed, Usuari destinatari);

	/**
	 * Retorna el pacient desxifrat i verificat pel destinatari informat en base al pacient xifrat
	 * facilitat, emprant la clau privada del destinatari
	 *
	 * @param pCiphed
	 *            pacient xifrat {@link PacientCiphed} que es preten desxifrar i verificar
	 * @param destinatari
	 *            {@link Usuari} amb quina clau privada s'intentarà desxifrar la informació
	 * @return Pacient desxifrat i verificat
	 */
	public Pacient verificarDesxifrarPacient(PacientCiphed pCiphed, Usuari destinatari);

	/**
	 * Retorna la visita desxifrada i verificada pel destinatari informat en base a la visita xifrada
	 * facilitat, emprant la clau privada del destinatari
	 *
	 * @param vCiphed
	 *            visita xifrada {@link VisitaCiphed} que es preten desxifrar i verificar
	 * @param destinatari
	 *            {@link Usuari} amb quina clau privada s'intentarà desxifrar la informació
	 * @return Visita desxifrada i verificada
	 */
	public Visita verificarDesxifrarVisita(VisitaCiphed vCiphed, Usuari destinatari);

	/**
	 * Retorna el set {@link Set} desxifrat que conté el conjunt de visites protegides
	 *
	 * @param visitesProtegides
	 *            {@link Set} conjunt de visites protegides signades i verificades pel Gestor
	 * @param destinatari
	 *            {@link Usuari} pel qual es preten desxifrar i verificar el set
	 * @return set {@link Set} amb el conjunt de visites desxifrades
	 */
	public Set<Visita> verificarDesxifrarVisitesProtegides(
			java.util.Set<VisitaCiphed> visitesProtegides, Usuari destinatari);

	/**
	 * Retorna el metge xifrat pel destinatari informat, emprant la clau pública del destinatari i
	 * la clau privada de l'emisor
	 *
	 * @param metge
	 *            {@link Metge} metge que es preten xifrar
	 * @param emisor
	 *            {@link Usuari} usuari emisor amb quina clau privada s'intentarà xifrar la
	 *            informació
	 * @param destinatari
	 *            {@link Usuari} usuari destinatari amb quina clau pública s'intentarà xifrar la
	 *            informació
	 * @return MetgeCiphed metge xifrat
	 */
	public MetgeCiphed xifrarMetge(Metge metge, Usuari emisor, Usuari destinatari);

	/**
	 * Retorna el pacient xifrat pel destinatari informat, emprant la clau pública del
	 * destinatari i la clau privada de l'emisor
	 *
	 * @param pacient
	 *            {@link Pacient} pacient que es preten xifrar
	 * @param emisor
	 *            {@link Usuari} usuari emisor amb quina clau privada s'intentarà xifrar la
	 *            informació
	 * @param destinatari
	 *            {@link Usuari} usuari destinatari amb quina clau pública s'intentarà xifrar la
	 *            informació
	 * @return PacientCiphed pacient xifrat
	 */
	public PacientCiphed xifrarPacient(Pacient pacient, Usuari emisor, Usuari destinatari);

	/**
	 * Retorna la llista {@link List} que conté el conjunt de pacients protegits xifrats per al
	 * destinatari informat. Primerament desxifra el conjunt de pacients xifrats pel destinatari i
	 * posteriorment els xifra per al destinatari emprant la clau pública del destinatari i la clau
	 * privada de l'emisor
	 *
	 * @param pacientsCiphed
	 *            {@link List} conjunt de pacients protegits xifrats pel Gestor
	 * @param emisor
	 *            {@link Usuari} emisor amb quina clau privada s'intentarà desxifrar la informació
	 * @param destinatari
	 *            {@link Usuari} usuari destinatari amb quina clau pública s'intentarà xifrar la
	 *            informació (una vegada estigui desxifrada)
	 * @return llista {@link List} amb el conjunt de pacients xifrats
	 */
	public List<PacientCiphed> xifrarPacientsProtegits(List<PacientCiphed> pacientsCiphed, Usuari emisor,
			Usuari destinatari);

	/**
	 * Retorna una petició xifrada pel destinatari informat en base a la petició en clar, emprant la
	 * seva clau pública i la clau privada de l'emisor
	 *
	 * @param peticio
	 *            {@link Peticio} peticio que es preten xifrar
	 * @param emisor
	 *            {@link Usuari} de la petició amb quina clau privada s'intentarà xifrar la
	 *            informació
	 * @param destinatari
	 *            {@link Usuari} destinatari amb quina clau pública s'intentarà xifrar la informació
	 * @return Petició xifrada
	 */
	public PeticioCiphed xifrarPeticio(Peticio peticio, Usuari emisor, Usuari destinatari);

	/**
	 * Retorna una resposta xifrada pel destinatari informat en base a la resposta en clar, emprant
	 * la seva clau pública i la clau privada de l'emisor
	 *
	 * @param resposta
	 *            {@link Resposta} resposta que es preten xifrar
	 * @param emisor
	 *            {@link Usuari} de la resposta amb quina clau privada s'intentarà xifrar la
	 *            informació
	 * @param destinatari
	 *            {@link Usuari} destinatari de la resposta amb quina clau pública s'intentarà
	 *            xifrar la informació
	 * @return Resposta xifrada
	 */
	public RespostaCiphed xifrarResposta(Resposta resposta, Usuari emisor, Usuari destinatari);

}
